home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / boot / netBoot.new / sys / fwritestr.c < prev    next >
C/C++ Source or Header  |  1990-12-19  |  18KB  |  695 lines
  1.  
  2. /*
  3.  * @(#)fwritestr.c 1.3 10/15/86
  4.  * Copyright (c) 1986 by Sun Microsystems, Inc.
  5.  */
  6.  
  7. /*
  8.  * Interpret a string of characters of length <len> into the frame buffer.
  9.  *
  10.  * Note that characters with the high bit set will not be recognized.
  11.  * This is good, for it reserves them for ASCII-8 X3.64 implementation.
  12.  * It just means all sources of chars which might come here must mask
  13.  * parity if necessary.
  14.  */
  15.  
  16. #include "../h/globram.h"
  17. #include "../h/dpy.h"
  18. #include "../h/video.h"
  19. #include "../sun3/cpu.addrs.h"
  20. #include "../h/enable.h"
  21. #include "../h/keyboard.h"
  22.  
  23. #ifndef GRUMMAN
  24.  
  25. #define CTRL(c) ('c'-64 & 127)
  26.  
  27.  
  28. fwritechar(c)
  29.     unsigned char c;
  30. {
  31.  
  32.     fwritestr(&c,1);
  33. }
  34.  
  35.  
  36. fwritestr(addr,len)
  37.     register unsigned char *addr;
  38.     register short len;        /* Declared short to get dbra - hah! */
  39. {
  40.     register char c;
  41.     int lfs;            /* Lines to feed on a LF */
  42.     
  43.     cursorcomp();
  44.     for (; --len != -1; ) {
  45.  
  46.     c = *addr++;        /* Fetch next char from string */
  47.  
  48. beginning:
  49.  
  50.     if (state & ESC) {
  51.         switch (c) {
  52.             case 0:        /*ignored*/
  53.             case CTRL(J):    /*ignored*/
  54.             case CTRL(M):    /*ignored*/
  55.             case CTRL([):    /*ignored*/
  56.             case CTRL(?):    /*ignored*/        continue;
  57.             /* Begin X3.64 sequence; enter alpha mode */
  58.             case '[':    state = ESCBRKT;
  59.                     cursor = BLOCKCURSOR;
  60.                                 continue;
  61.             /* Clear screen and enter alpha mode */
  62.             case CTRL(L):    state = ALPHA;
  63.                     cursor = BLOCKCURSOR;
  64.                     pos(LEFT,TOP);
  65.                     rectfill(0,0,SCRWIDTH,SCRHEIGHT);
  66. #ifdef PRISM
  67.                     rect_enable(0,0,SCRWIDTH,SCRHEIGHT,
  68.                             0xFFFF);
  69.                         /* enable the mono FB */
  70. #endif PRISM
  71.                                 continue;
  72.             /* Simulate DEL char for systems that can't xmit it */
  73.             case '?':    c = CTRL(?);
  74.                     state &= ~ESC;        break;
  75.  
  76.             /* By default, ignore the character after the ESC */
  77.             default:    state &= ~ESC;
  78.                     continue;
  79.         }
  80.     }
  81.  
  82.     switch (state) {
  83.  
  84.     case ALPHA:
  85.         ac = 0;
  86.         ac0 = -1;
  87.         switch (c) {
  88.             case CTRL(G):    blinkscreen();        break;
  89.             case CTRL(H):    pos(ax-1,ay);         break;
  90.             case CTRL(I):    pos((ax&-8)+8,ay);     break;
  91.             case CTRL(J):    /* linefeed */
  92.     /* Linefeed is complicated, so it gets its own indentation */
  93. FeedLine:
  94.     if (ay < BOTTOM-1) {
  95.         /* pos(ax,ay+1); */
  96.         ay++;
  97.         fbpos.pos.y += CHRHEIGHT;
  98.         if (!scrlins) /* ...clear line */
  99.             delchar(0,RIGHT,ay);
  100.     } else {
  101.         if (!scrlins) {  /* Just wrap to top of screen and clr line */
  102.             pos (ax,0);
  103.             delchar(0,RIGHT,ay);
  104.         } else {
  105.             lfs = scrlins;    /* We will scroll, but how much? */
  106.             if (lfs == 1) {
  107.                 /* Find pending LF's and do them all now */
  108.                 unsigned char *cp = addr;
  109.                 short left = len;
  110.  
  111.                 for (; --len != -1; addr++) {
  112.                          if (*addr == CTRL(J)) lfs++;
  113.                     else if (*addr == CTRL(M)) ;
  114.                     else if (*addr >= ' ')     ;
  115.                     else if (*addr > CTRL(J)) break;
  116.                 }
  117.                 len = left; addr = cp;
  118.             }
  119.             if (lfs > BOTTOM) lfs = BOTTOM;
  120.             delline (TOP, TOP+lfs);
  121.             if (lfs != 1) /* avoid upsetting <dcok> for nothing */
  122.                 pos (ax, ay+1-lfs);
  123.         }
  124.     }
  125.     break;
  126.             case CTRL(K):    pos(ax,ay-1); /* 4014 */    break;
  127.             case CTRL(L):    pos(LEFT,TOP);
  128.                     rectfill(0,0,SCRWIDTH,SCRHEIGHT);
  129. #ifdef PRISM
  130.                     rect_enable(0,0,SCRWIDTH,SCRHEIGHT,
  131.                             0xFFFF);
  132.                         /* enable the mono FB */
  133. #endif PRISM
  134.             case CTRL(M):    /* pos(0,ay); */
  135.                     ax = 0;
  136.                     fbpos.pos.x = WINLEFT;
  137.                     break;
  138.             case CTRL([):    state |= ESC;         break;
  139.             case CTRL(?):    /* ignored */        break;
  140.  
  141.             default:
  142.  
  143.                 c -= 32;
  144.                 if (c >= 0)
  145.                 {
  146.                 /* Write character on the screen. */
  147.                 drawchr (font[c], chrfunc);
  148.                 /* Update cursor position.  Inline for speed. */
  149.                 if (ax < RIGHT-1) {
  150.                     ax++;
  151.                     fbpos.pos.x += CHRWIDTH;
  152.                 } else {
  153.                     /* Wrap to col 1, pretend LF seen */
  154.                     ax = 0;
  155.                     fbpos.pos.x = WINLEFT;
  156.                     goto FeedLine;
  157.                 }
  158.                 }
  159.                 break;
  160.         }  /* end of case ALPHA switch statement */
  161.         break;
  162.  
  163.     case ESCBRKT:
  164.         if ('0' <= c && c <= '9') {
  165.             ac = ((char)ac)*10 + c - '0'; /* char for inline muls */
  166.         } else if (c == ';') {
  167.             ac0 = ac; ac = 0;
  168.         } else {
  169.             acinit = ac;
  170.             if (ac == 0) ac = 1;    /* Default value is 1 */
  171.             switch ( c ) {
  172.             case '@':    inschar(ax,ax+ac,ay);    break;
  173.             case 'A':    pos(ax,ay-ac);         break;
  174.             case 'B':    pos(ax,ay+ac);         break;
  175.             case 'C':    pos(ax+ac,ay);         break;
  176.             case 'D':    pos(ax-ac,ay);         break;
  177.             case 'E':    pos(LEFT,ay+ac);        break;
  178.             case 'f':
  179.             case 'H':
  180.                     if (ac0 < 0) pos(0,ac-1);
  181.                     else         pos(ac-1,ac0-1);    break;
  182.             case 'J':    delline(ay+1,BOTTOM); /* no break */
  183.             case 'K':    delchar(ax,RIGHT,ay);        break;
  184.             case 'L':    insline(ay,ay+ac);         break;
  185.             case 'M':    delline(ay,ay+ac);        break;
  186.             case 'P':    delchar(ax,ax+ac,ay);        break;
  187.             case 'm':    chrfunc = fillfunc^
  188.                       ((acinit == 0)? 
  189.                         POX_SRC:
  190.                         POX_NOT(POX_SRC)
  191.                                   );    break;
  192.             /* Sun-2 0-bits are white, 1-bits are black. */
  193.             case 'p':    if (fillfunc != POX_CLR)
  194.                         screencomp();        break;
  195.             case 'q':    if (fillfunc != POX_SET)
  196.                         screencomp();        break;
  197.             case 'r':    scrlins = acinit;        break;
  198.             case 's':    finit(ax, ay);            break;
  199.             default:    /* X3.64 sez ignore if we don't know */
  200.                     if ((c < '@')) {
  201.                         state = SKIPPING;
  202.                         continue;
  203.                     }
  204.             }
  205.         state = ALPHA;
  206.         }
  207.         break;
  208.  
  209.     case SKIPPING:    /* Waiting for char from cols 4-7 to end esc string */
  210.         if (c < '@') break;
  211.         state = ALPHA;
  212.         break;
  213.  
  214.     default:
  215.         /* Deal with graphics states if 2nd prom exists, else just
  216.            go to ALPHA mode and reinterpret the character. */
  217.         state = ALPHA;
  218.         cursor = BLOCKCURSOR;
  219.         goto beginning;
  220.     }
  221.     }            /* End of for loop thru string of chars */
  222.  
  223.     cursorcomp();    /* Restore the cursor to the screen */
  224. }
  225.  
  226.  
  227. pos(x,y)
  228.     int x, y;
  229. {
  230.  
  231.     dcok = 0;    /* We've changed ax or ay and not dcax,dcay */
  232.  
  233.     ax = x < LEFT?        LEFT:
  234.          x >= RIGHT?    RIGHT-1:
  235.                 x;
  236.  
  237.     ay = y < TOP?         TOP:
  238.          y >= BOTTOM?    BOTTOM-1:
  239.                 y;
  240. }
  241.  
  242.  
  243. cursorcomp()
  244. {
  245.  
  246.     if (cursor != NOCURSOR)
  247. /* The 2nd param (font) is used as the source for the character sent to the
  248.    frame buffer.  However, the function we are using ignores the source,
  249.    so we just punt with  font .     */
  250.         drawchr(font, POX_NOT(POX_DST));
  251. }
  252.  
  253. screencomp()
  254. {
  255.  
  256.     invertwholescreen();
  257.     chrfunc = POX_NOT(chrfunc);
  258.     fillfunc = POX_NOT(fillfunc);
  259. }
  260.  
  261. blinkscreen()
  262. {
  263.     struct videoctl copyvid;
  264.     int i = 10000;
  265.  
  266.     if (gp->g_insource == INKEYB) {
  267.         while (!sendtokbd(KBD_CMD_BELL)) if (0 == --i) return;
  268.         while (--i);
  269.         (void) sendtokbd(KBD_CMD_NOBELL);
  270.         return;
  271.     }
  272.  
  273.     set_enable(get_enable() & ~ENA_VIDEO);    /* Disable video output */
  274.     while (i--);            /* Wait a moment... */
  275.     set_enable(get_enable() |  ENA_VIDEO);    /* Enable  video output */
  276. }
  277.  
  278. #ifndef PRISM
  279.  
  280. /*
  281.  * Copy one rectangle in the frame buffer to another.
  282.  * On the Sun-2, without RasterOp support, this only works word-aligned.
  283.  */
  284. rectcopy(fromxlo,fromylo,fromxhi,fromyhi,tox,toy)
  285.     int fromxlo, fromylo, fromxhi, fromyhi, tox, toy;
  286. {
  287.     int y, yy, toyy;
  288.     int width, height;
  289.     
  290.     if (fromxlo < 0) fromxlo = 0;
  291.     if (fromylo < 0) fromylo = 0;
  292.     if (fromxhi > SCRWIDTH) fromxhi = SCRWIDTH;
  293.     if (fromyhi > SCRHEIGHT) fromyhi = SCRHEIGHT;
  294.     if (tox < 0) tox = 0;
  295.     if (toy < 0) toy = 0;
  296.  
  297.     yy =   GXBase + (fromxlo >> 3) +
  298.         ((unsigned short)fromylo * (unsigned short)(SCRWIDTH >> 3));
  299.     toyy = GXBase + (tox     >> 3) +
  300.         ((unsigned short)toy     * (unsigned short)(SCRWIDTH >> 3));
  301.     width = (fromxhi - fromxlo) >> 3;
  302.  
  303.     if (fromylo >= toy) {
  304.         for (y = fromylo;
  305.              y < fromyhi;
  306.              y++, yy += SCRWIDTH>>3, toyy += SCRWIDTH>>3) {
  307.             bltshort(yy, yy+width, toyy);
  308.         }
  309.     } else {
  310.         height = ((unsigned short)(fromyhi - fromylo)) * 
  311.               (unsigned short)(SCRWIDTH >> 3);
  312.         yy += height;
  313.         toyy += height;
  314.         for (y = fromyhi-1;
  315.              y >= fromylo;
  316.              y--, yy -= SCRWIDTH>>3, toyy -= SCRWIDTH>>3) {
  317.             bltshort(yy, yy+width, toyy);
  318.         }
  319.     }    /* if (fromylo>=toy).. else */
  320. }    /* end of rectcopy() */
  321.  
  322. #endif PRISM    /* end of ifndef PRISM */
  323.  
  324.  
  325. #ifdef PRISM
  326.  
  327. /*
  328.  *  rectcopy() for prism is similar to the nonprism rectcopy.  The difference
  329.  *  is that we do the same thing to the enable plane as we do to the monochrome
  330.  *  frame buffer.
  331.  */
  332. rectcopy(fromxlo,fromylo,fromxhi,fromyhi,tox,toy)
  333.     int fromxlo, fromylo, fromxhi, fromyhi, tox, toy;
  334. {
  335.     int y, yy, toyy;
  336.     int width, height;
  337.     short    i;
  338.     int Base;
  339.     
  340.     if (fromxlo < 0) fromxlo = 0;
  341.     if (fromylo < 0) fromylo = 0;
  342.     if (fromxhi > SCRWIDTH) fromxhi = SCRWIDTH;
  343.     if (fromyhi > SCRHEIGHT) fromyhi = SCRHEIGHT;
  344.     if (tox < 0) tox = 0;
  345.     if (toy < 0) toy = 0;
  346.  
  347.    for (i=1, Base=GXBase; i < 3; i++, Base=(int)BW_ENABLE_MEM_BASE) {
  348.     yy =   Base + (fromxlo >> 3) +
  349.         ((unsigned short)fromylo * (unsigned short)(SCRWIDTH >> 3));
  350.     toyy = Base + (tox     >> 3) +
  351.         ((unsigned short)toy     * (unsigned short)(SCRWIDTH >> 3));
  352.     width = (fromxhi - fromxlo) >> 3;
  353.  
  354.     if (fromylo >= toy) {
  355.         for (y = fromylo;
  356.              y < fromyhi;
  357.              y++, yy += SCRWIDTH>>3, toyy += SCRWIDTH>>3) {
  358.             bltshort(yy, yy+width, toyy);
  359.         }
  360.     } else {
  361.         height = ((unsigned short)(fromyhi - fromylo)) * 
  362.               (unsigned short)(SCRWIDTH >> 3);
  363.         yy += height;
  364.         toyy += height;
  365.         for (y = fromyhi-1;
  366.              y >= fromylo;
  367.              y--, yy -= SCRWIDTH>>3, toyy -= SCRWIDTH>>3) {
  368.             bltshort(yy, yy+width, toyy);
  369.         }
  370.     }    /* if (fromylo>=toy).. else */
  371.    }    /* for (i=1...) */
  372. }    /* end of rectcopy() */
  373.  
  374. #endif PRISM
  375.  
  376.  
  377. /*
  378.  *    Draw the character pointed to (in the font) by  p at position  ax,
  379.  *    ay  on the screen (global variables) using function f
  380.  */
  381.  
  382. drawchr(p,f)
  383.     short *p;
  384.     int f;
  385. {
  386.  
  387.     /* FIXME: maybe avoid multiplies in batchrop too, by fudging addr? */
  388.     if (!dcok) {
  389.         fbpos.pos.x = WINLEFT + ax * CHRWIDTH;
  390.         fbpos.pos.y = WINTOP  + ay * CHRHEIGHT;
  391.         dcok = 1;
  392.     }
  393.     chardata.md_image = p;
  394.  
  395. #ifdef PRISM
  396.     rect_enable(fbpos.pos.x, fbpos.pos.y, fbpos.pos.x + 0x10,
  397.             fbpos.pos.y+CHRHEIGHT, 0xFFFF);
  398.             /*
  399.              * enable a block big enough for 1 character.
  400.              * A character is 12 wide by 22 high.  However, rect_enable
  401.              * fills in at least 16 bits (short word) at a time; so
  402.              * we're actually enabling a block 16 wide by 22 high.
  403.              */
  404. #endif PRISM
  405.  
  406.     prom_mem_batchrop(fbpos, f, &charpos, 1);
  407. }
  408.  
  409. /*
  410.  *  FOR PRISM ONLY:
  411.  *
  412.  *  rect_enable enables or disables a rectangle in the enable plane.
  413.  *
  414.  *    rect_enable(xlo,ylo,xhi,yhi,0xFFFF)  enables a rect in the
  415.  *        monochrome FB.
  416.  *    rect_enable(xlo,ylo,xhi,yhi,0)  disables a rect in the monochrome FB.
  417.  *
  418.  *  The enable plane is originally setup by the bootprom as having enabled
  419.  *  the BW frame buffer, but we can't guaranteed that'll be the case when
  420.  *  other programs execute and since the kernel uses the bootprom monitor
  421.  *  to display console messages, we must make sure that the locations where
  422.  *  the message is to appear must be enabled.  Typically, this routine is
  423.  *  called by draw_char to enable a block big enough for 1 character;
  424.  *  rect_enable is also called in other places, usually to enable the
  425.  *  entire monochrome plane.
  426.  */
  427.  
  428. #ifdef PRISM
  429. rect_enable(xlo,ylo,xhi,yhi,pattern)
  430.     unsigned short pattern;
  431.         /*
  432.          * xlo, ylo, xhi, and yhi are pixel positions; each pixel
  433.          * is a bit.
  434.          */
  435. {
  436.     int yy, width;
  437.     unsigned short y;
  438.  
  439.     width = (xhi - xlo) >> 3;    /* change to bytes */
  440.     y = ylo;
  441.     yy = (int)BW_ENABLE_MEM_BASE + (y * (unsigned short)(SCRWIDTH >> 3)) +
  442.          (xlo >> 3);
  443.     for (; y < yhi; y++, yy += SCRWIDTH >> 3) {
  444.         setshort(yy, yy+width, pattern);
  445.             /*
  446.              * a 1 bit enables each pixel to monochrome; so need to
  447.              * fill in 0xFFFF (for enabling) since setshort() uses
  448.              * the pattern as a 16 bit (short) word.
  449.              */
  450.     }
  451. }
  452. #endif PRISM
  453.  
  454. /*
  455.  * Fill a rectangle on the screen with black or white.
  456.  * For the Sun-2 without RasterOp support, only works on word boundaries.
  457.  */
  458. rectfill(xlo,ylo,xhi,yhi)
  459. {
  460.     int yy, width, filler;
  461.     unsigned short y;
  462.  
  463.     width = (xhi - xlo) >> 3;    /* Bytes of difference */
  464.     filler = (fillfunc == POX_SET)? -1: 0;
  465.     y = ylo;
  466.     yy = GXBase + (y * (unsigned short)(SCRWIDTH >> 3)) + (xlo >> 3);
  467.     for (;
  468.          y < yhi;
  469.          y++, yy += SCRWIDTH >> 3) {
  470.         setshort(yy, yy+width, filler);
  471.     }
  472. }
  473.  
  474.  
  475. /*
  476.  * Invert the entire screen.
  477.  */
  478. invertwholescreen()
  479. {
  480.     register long *q, *end;
  481.     register long invert = -1;
  482.  
  483.     q = (long *)GXBase;
  484. #ifdef SIRIUS
  485.     end = (long *) (GXBase + 256*1024);
  486. #else
  487.     end = (long *) (GXBase + 128*1024);
  488. #endif SIRIUS
  489.  
  490.     for (; q < end; q++) *q ^= invert;
  491. }
  492.  
  493. /* now its var gp->g_winbot  init'd in finit.c */
  494. #ifndef SIRIUS
  495. #define    WINBOT (WINTOP+BOTTOM*CHRHEIGHT) 
  496. #endif SIRIUS
  497. #define    WINRIGHT (WINLEFT+RIGHT*CHRWIDTH)
  498.  
  499. /* delete lines a (inclusive) to b (exclusive) */
  500. delline(a,b)
  501.     unsigned char a, b;
  502. {
  503.     register pixla = a*CHRHEIGHT, pixlb = b*CHRHEIGHT;
  504.  
  505.     rectcopy(0,WINTOP+pixlb,        SCRWIDTH,WINBOT,
  506.          0,WINTOP+pixla);
  507.     rectfill(0,WINBOT-(pixlb-pixla),    SCRWIDTH,SCRHEIGHT);
  508. #ifdef PRISM
  509.     rect_enable(0,WINBOT-(pixlb-pixla),    SCRWIDTH,SCRHEIGHT, 0xffff);
  510. #endif PRISM
  511. }
  512.  
  513. /* insert (make room for) lines a (inclusive) to b (exclusive) */
  514. insline(a,b)
  515.     unsigned char a, b;
  516. {
  517.     register pixla = a*CHRHEIGHT, pixlb = b*CHRHEIGHT;
  518.  
  519.     rectcopy(0,WINTOP+pixla,    SCRWIDTH,WINBOT-(pixlb-pixla),
  520.          0,WINTOP+pixlb);
  521.     rectfill(0,WINTOP+pixla,    SCRWIDTH,WINTOP+pixlb);
  522. }
  523.  
  524. /*
  525.  * delete chars a (inclusive) to b (exclusive) on line l
  526.  *
  527.  * One by one, we move any characters that need to slide.
  528.  * We fill one character position by drawing a blank there,
  529.  * then we know that rounding the cursor position down to a 16-bit boundary
  530.  * is good enough to fill the rest of the line.
  531.  */
  532. delchar(a, b, l)
  533.     unsigned char a, b, l;
  534. {
  535.     int savex = ax;
  536.     int savey = ay;
  537.     register int apos, bpos;
  538.     short achar[CHRSHORTS];
  539.     
  540.     if (b < RIGHT) {
  541.         /*
  542.          * We have to actually shift characters.
  543.          */
  544.         fbpos.pos.y = WINTOP + l * CHRHEIGHT;    /* All on this line */
  545.         apos = WINLEFT + a * CHRWIDTH;
  546.         bpos = WINLEFT + b * CHRWIDTH;
  547.         chardata.md_image = achar;    /* Here's temp char location */
  548.         for (;bpos < WINRIGHT;
  549.               apos += CHRWIDTH, bpos += CHRWIDTH) {
  550.             fbpos.pos.x = bpos;
  551.             prom_mem_grab(fbpos, 0, &charpos, 0);
  552.             fbpos.pos.x = apos;
  553.             prom_mem_batchrop(fbpos, PIX_SRC, &charpos, 1);
  554.         }
  555.         ax = RIGHT-(b-a);    /* Position to fill from */
  556.     } else {
  557.         ax = a;            /* Position to fill from */
  558.     }
  559.  
  560.     ay = l;
  561.     dcok = 0;        /* We're doing severe play with dev. coords */
  562.     drawchr(font, fillfunc);    /* Fill one char position there */
  563.     
  564.     /* OK, that character has been filled; now do the rest. */
  565.     rectfill( (fbpos.pos.x + CHRWIDTH) &~ 0x000F,
  566.          fbpos.pos.y, 
  567.          SCRWIDTH,
  568.          fbpos.pos.y+CHRHEIGHT);
  569.     
  570.     pos(savex, savey);        /* Clean up our grunge */
  571. }
  572.  
  573. /* insert (make room for) chars a (inclusive) to b (exclusive) on line l */
  574. inschar(a, b, l)
  575.     unsigned char a, b, l;
  576. {
  577.     int savex = ax;
  578.     int savey = ay;
  579.     register int apos, bpos;
  580.     register short temp;
  581.     short achar[CHRSHORTS];
  582.     
  583.     if (b > RIGHT) b = RIGHT;        /* Avoid problems */
  584.  
  585.     fbpos.pos.y = WINTOP + l * CHRHEIGHT;    /* All on this line */
  586.     bpos = WINRIGHT - CHRWIDTH;        /* Start on last char */
  587.     apos = bpos - (b - a) * CHRWIDTH;    /* Copy from N chars back */
  588.     chardata.md_image = achar;    /* Here's temp char location */
  589.     temp = RIGHT - b;            /* How many to copy */
  590.  
  591.     for (;temp-- != 0;
  592.           apos -= CHRWIDTH, bpos -= CHRWIDTH) {
  593.         fbpos.pos.x = apos;
  594.         prom_mem_grab(fbpos, 0, &charpos, 0);
  595.         fbpos.pos.x = bpos;
  596.         prom_mem_batchrop(fbpos, PIX_SRC, &charpos, 1);
  597.     }
  598.  
  599.     ax = a; ay = l;        /* Position to fill from */
  600.     dcok = 0;        /* We're doing severe play with dev. coords */
  601.     for (; a < b; a++, fbpos.pos.x += CHRWIDTH) {
  602.         drawchr(font, fillfunc);    /* Fill one char position */
  603.     }
  604.  
  605.     pos(savex, savey);
  606. }
  607.  
  608. static unsigned    logo_data[128] = {
  609.             0x00000003, 0xC0000000, 0x0000000F, 0xF0000000,
  610.             0x0000001F, 0xF8000000, 0x0000003F, 0xFC000000,
  611.             0x0000003F, 0xFE000000, 0x0000007F, 0xFF000000,
  612.             0x0000007E, 0xFF800000, 0x0000027F, 0x7FC00000,
  613.             0x0000073F, 0xBFE00000, 0x00000FBF, 0xDFF00000,
  614.             0x00001FDF, 0xEFF80000, 0x00002FEF, 0xF7FC0000,
  615.             0x000077F7, 0xFBFE0000, 0x0000FBFB, 0xFDFF0000,
  616.             0x0001FDFD, 0xFEFF0000, 0x0001FEFE, 0xFF7EC000,
  617.             0x0006FF7F, 0x7FBDE000, 0x000F7FBF, 0xBFDBF000,
  618.             0x001FBFDF, 0xDFE7F800, 0x003FDFEF, 0xEFEFF400,
  619.             0x007FAFF7, 0xF7DFEE00, 0x00FF77FB, 0xF3BFDF00,
  620.             0x01FEFBFD, 0xF97FBF80, 0x03FDFDFF, 0xF8FF7F00,
  621.             0x07FBF8FF, 0xF9FEFE00, 0x0FF7F07F, 0xF3FDFCE0,
  622.             0x1FEFE73F, 0xF7FBFBF8, 0x3FDFDFDF, 0xEFF7F7FC,
  623.             0x7FBFBFE7, 0x9FEFEFFE, 0x7F7F7FE0, 0x1FDFDFFE,
  624.             0xFEFEFFF0, 0x3FBFBFFF, 0xFDFDFFF0, 0x3F7F7FFF,
  625.             0xFFFBFBF0, 0x3FFEFF7F, 0xFFF7F7F0, 0x3FFDFEFF,
  626.             0x7FEFEFE0, 0x1FFBFDFE, 0x7FDFDFE7, 0x9FF7FBFE,
  627.             0x3FBFBFDF, 0xEFEFF7FC, 0x0E7F7FBF, 0xF39FEFF8,
  628.             0x00FEFF3F, 0xF83FDFF0, 0x01FDFE7F, 0xFC7FBFE0,
  629.             0x03FBFC7F, 0xFEFF7FC0, 0x01F7FA7E, 0xFF7EFF80,
  630.             0x00EFF73F, 0x7FBDFF00, 0x005FEFBF, 0xBFDBFE00,
  631.             0x003FDFDF, 0xDFE7FC00, 0x001FAFEF, 0xEFF7F800,
  632.             0x000F77F7, 0xF7FBF000, 0x0006FBFB, 0xFBFDE000,
  633.             0x0001FDFD, 0xFDFEC000, 0x0001FEFE, 0xFEFF0000,
  634.             0x0000FF7F, 0x7F7F0000, 0x00007FBF, 0xBFBE0000,
  635.             0x00003FDF, 0xDFDC0000, 0x00001FEF, 0xEFE80000,
  636.             0x00000FF7, 0xF7F00000, 0x000007FB, 0xFBE00000,
  637.             0x000003FD, 0xF9C00000, 0x000001FE, 0xFC800000,
  638.             0x000000FF, 0xFC000000, 0x0000007F, 0xFC000000,
  639.             0x0000003F, 0xF8000000, 0x0000001F, 0xF8000000,
  640.             0x0000000F, 0xF0000000, 0x00000003, 0xC0000000
  641.         };
  642.  
  643. /*
  644.  *    Draw the Sun logo, starting on line (y) on screen.
  645.  *    No clipping, y must be valid.
  646.  */
  647.  
  648. sunlogo(y)
  649.     unsigned short y;
  650. {
  651.     register long *addr, *logo;
  652.     register short i;
  653.     
  654.     addr = (long *) (GXBase +
  655.         (unsigned short)((WINTOP + y * CHRHEIGHT)) * 
  656.         (unsigned short)(SCRWIDTH/8)
  657.         + 2*(WINLEFT/16) );
  658.     logo = (long *) logo_data;
  659.     for (i = 64; i-- != 0;) {
  660. #ifndef    SIRIUS
  661.         if (chrfunc == POX_SRC) {
  662.             *addr++ = *logo++;
  663.             *addr++ = *logo++;
  664.         } else {
  665.             *addr++ = ~*logo++;
  666.             *addr++ = ~*logo++;
  667.         }
  668. #else    SIRIUS
  669.         *addr++ = *logo++;
  670.             *addr++ = *logo++;
  671. #endif    SIRIUS
  672.         addr += (SCRWIDTH/32) - 2;    /* -2 for the autoincs */
  673.     }
  674. }
  675.  
  676. #endif GRUMMAN    /* end of ifndef GRUMMAN */
  677.  
  678. #ifdef GRUMMAN
  679.  
  680. fwritechar(c)
  681.     unsigned char c;
  682. {
  683.     return;
  684. }
  685.  
  686. fwritestr(addr,len)
  687.     register unsigned char *addr;
  688.     register short len;
  689. {
  690.     return;
  691. }
  692.  
  693. #endif GRUMMAN
  694.  
  695.